<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <!-- 关于一个数据对象如何添加新的属性 -->
    <script src="./index.js"></script>
    <script>
        var geyao = [{
            name: 'geyao',
            age: 18,
            sex: '男'
        }, {
            name: 'fangfang',
            age: 18,
            sex: '女'
        },
        {
            name: 'geyao1',
            age: 19,
            sex: '男'
        }, {
            name: 'fangfang1',
            age: 20,
            sex: '女'
        }]
        console.log(geyao, "初始化数据")
        var newgeyao = geyao.map(function (item, index) {
            return {
                ...item,
                collage: '本科'
            }
        })
        console.log(geyao, newgeyao, "最终属性map")
        // map有返回值 不改变原数组 
        var newgeyaoforeach = geyao.forEach(function (item, index) {
            item.address = '江苏'
        })
        console.log(geyao, newgeyaoforeach, "最终属性foreach")
        var newgeyaofilter = geyao.filter(function (item, index) {
            return item.age > 18
        })
        console.log(geyao, newgeyaofilter, "最终属性filter")

        // every使用
        // 判断数组中的所有条件是否全部符合 true false
        var newgeyaoevery = geyao.every(function (item, index) {
            return item.age > 18
        })
        console.log(geyao, newgeyaoevery, "最终属性every")
        //判断数组中的所有条件是否存在符合条件的元素 true false
        var newgeyaosome = geyao.some(function (item, index) {
            return item.age > 19
        })
        console.log(geyao, newgeyaosome, "最终属性some")
        var newgeyaoindex = geyao.findIndex(function (item, index) {
            return item.age === 19
        })
        console.log(geyao, newgeyaoindex, "最终属性findindex")

        var newgeyaofind = geyao.find(function (item, index) {
            if (item.age === 18) {
                return true
            }
        })
        console.log(geyao, newgeyaofind, "最终属性find")

        //  var oldcancat = ["geyao"]
        //  var origincancat = ["isnice"]
        //  var newcancat = oldcancat.concat(origincancat)
        //  console.log(oldcancat,origincancat,newcancat,"最终属性concat")

       
        var oldcancat = ['geyao']

        var origincancat = ['isgood']

        var newcancat = oldcancat.concat(origincancat)

        console.log(oldcancat, origincancat, newcancat, "最终属性concat")

        var oldpush = ['geyao']

        var newoldpush = oldpush.push("isgood")

        console.log(newoldpush, oldpush, "最终属性push")

        var oldpop = ["geyao", "fangfang", "good"]

        var newoldpop = oldpop.pop()

        console.log(newoldpop, oldpop, "最终属性pop")

        var oldunshift = ["geyao", "fangfang", "good"]

        var newoldunshift = oldunshift.unshift("xinnian")

        console.log(newoldunshift, oldunshift, "最终属性unshift")

        var oldshift = ["geyao", "fangfang", "good"]

        var newoldshift = oldshift.shift()

        console.log(newoldshift, oldshift, "最终属性shift")

        var oldincludes = ["geyao", "fangfang", "good"]

        var newoldincludes = oldincludes.includes('good')

        console.log(newoldincludes, oldincludes, "最终属性includes")

        var oldsplice = ["geyao", "fangfang", "good"]
        // var newoldsplice = oldsplice.splice(0,1)
        var newoldspliceinter = oldsplice.splice(0, 1, "xinnian")
        console.log(newoldspliceinter, oldsplice, "最终属性splice")
        // ["geyao","xinnian","good"]

        var oldslice = ["geyao", "fangfang", "good"]

        var newoldslice = oldslice.slice(0, 1)

        console.log(newoldslice, oldslice, "最终属性slice")

        var oldsort = [{
            "name": "geyao",
            "age": 18
        }, {
            "name": "fangfang",
            "age": 19
        }, {
            "name": "good",
            "age": 20
        }]

        var newoldsort = oldsort.sort((a, b) => {
            return b.age - a.age
        })
        console.log(newoldsort, oldsort, "最终属性sort")

        var oldreduce = [{
            "name": "geyao",
            "age": 18
        }, {
            "name": "fangfang",
            "age": 19
        }, {
            "name": "good",
            "age": 20
        }]
        var newoldreduce = oldreduce.reduce((a, b) => {
            return {
                "name": a.name + b.name,
                "age": a.age + b.age
            }
        })
        console.log(newoldreduce, oldreduce, "最终属性reduce")

        var oldreserve = [1,2,3]

        var newoldreverse = oldreserve.reverse()

        console.log(newoldreverse, oldreserve, "最终属性reverse")

        var oldjoin = [1,2,3]
        var newoldjoin = oldjoin.join("/")
        console.log(newoldjoin, oldjoin, "最终属性join")
        var oldsplit = '1/2/3/4'
        var newoldsplit = oldsplit.split("/")
        console.log(newoldsplit, oldsplit, "最终属性split")

        var oldfill = ["geyao", "fangfang", "good"]
        // var newoldfill = oldfill.fill(1)
        // ["1", "1", "1"]
        // var newoldfill = oldfill.fill(1, 2)
        //["geyao", "fangfang", "1"]
        var newoldfill = oldfill.fill(1, 1, 2)
        //["geyao", "1", "good"]
        console.log(newoldfill, oldfill, "最终属性fill")

        var oldreduceRight = [{
            "name": "geyao",
            "age": 18
        }, {
            "name": "fangfang",
            "age": 19
        }, {
            "name": "good",
            "age": 20
        }]
        var newoldreduceRight = oldreduceRight.reduceRight((a, b) => {
            return {
                "name": a.name + b.name,
                "age": a.age + b.age
            }
        })
        console.log(newoldreduceRight, oldreduceRight, "最终属性reduceRight")

        var oldreduceRightNum = [1, 2, 3, 4, 5]
        var newoldreduceRightNum = oldreduceRightNum.reduceRight((a, b) => {
            return a + b
        },1)
        console.log(newoldreduceRightNum, oldreduceRightNum, "最终属性reduceRightNum")

        var oldcopywithin = [1,2,3,4,5]
        var newoldcopywithin = oldcopywithin.copyWithin(0,2,4)
        // [3,4,3,4,5]
        console.log(newoldcopywithin, oldcopywithin, "最终属性copywithin")

        var oldlastIndexOf = ["good","fangfang","good"]

        var newoldlastIndexOf = oldlastIndexOf.lastIndexOf("good")

        console.log(newoldlastIndexOf, oldlastIndexOf, "最终属性lastIndexOf")

        var oldIndexOf = ["good","fangfang","good"]
        var newoldIndexOf = oldIndexOf.indexOf("good")
        console.log(newoldIndexOf, oldIndexOf, "最终属性indexOf")

        var oldobject = {
            "name": "geyao",
            "age": 18,
            "sex": "man",
            "hobby": ["daima"]
        }
        var newoldobjectkeys = Object.keys(oldobject)
        console.log(newoldobjectkeys, oldobject, "最终属性keys")
        var newoldobjectvalues = Object.values(oldobject)
        console.log(newoldobjectvalues, oldobject, "最终属性values")
        var newoldobjectentries = Object.entries(oldobject)
        console.log(newoldobjectentries, oldobject, "最终属性entries")

        var oldForOf = [{
            "name": "geyao",
            "age": 18
        }, {
            "name": "fangfang",
            "age": 19
        }, {
            "name": "good",
            "age": 20
        }]
        for (let i of oldForOf) {
            // 值
            console.log(i,"forof")
        }
        // 可迭代对象

        var oldForIn = [{
            "name": "geyao",
            "age": 18
        }, {
            "name": "fangfang",
            "age": 19
        }, {
            "name": "good",
            "age": 20
        }]

        for (let i in oldForIn) {
            // 键值对
            console.log(i,oldForIn[i],'"forin"')
        }





      
        //1 map有返回值 不改变原数组 
        //2 foreach 没有返回值 改变原数组
        //3 filter 有返回值 不改变原数组
        //4 every 判断数组中的所有数据是否满足条件 返回true 否则返回false
        //5 some  判断数组中的是否存在数据是否满足条件 返回true 否则返回false
        //6 findindex 寻找优先符合条件的第一个属性的索引
        //7 find寻找符合条件的第一个元素返回出来 不改变原始数组的值
        //8 cancat就是将我们的初始数组和目标数组进行一个拼接 返回一个新的数组 不影响原数组
        //9 push是可以改变原数组 是对数组的元素进行一个追加 返回值是新数组的长度
        //10 pop是对数组的最后一个元素进行删除操作 返回值是删除的属性 会改变我们的原数组
        //11 unshift是可以改变原数组 是对数组的元素进行一个追加最前面进行追加 返回值是新数组的长度
        //12 shift是对数组的第一一个元素进行删除操作 返回值是删除的属性 会改变我们的原数组
        //13 includes是判断
        // 数组中是否包含某个属性 是的话返回true 否则返回false 这就是includes的一个使用
        // 14splice 第一个参数大于等于第二个参数的时候 第一个参数表示要放入的一个位置 第二个参数表示要删除的元素个数
        // 可以实现删除和增加操作
        // 15 slice 是对数组进行一个截取操作 两个参数截取索引A到索引b的下表的元素 
        // 只有一个参数 比数组的长度大 就不进行截取 比数组长度小 就截取到最后
        // 16sort对数据进行一个升序和降序排列 会改变原数组 返回值是排序后的数组
        // 17reduce对数据进行一个累计操作 不会改变原数组 返回值是累计后的值
        // 求和属性相加等计算
        // 18reverse 对数组进行一个倒序操作 会改变原数组 没有返回值
        // 19join 对数组进行一个拼接操作 不会改变原数组 返回值是拼接后的字符串
        // 简单应用 select框 labal value 后端存储的是字符串 这个时候我们就需要使用这个属性join 展示和后端传值不一样
        // 20 split 对字符串进行一个分割操作 会形成一个新数组 返回值是分割后的数组
        // 21fill是一个参数的时候就会给我们的所有值替换
        // 两个参数的时候第一个表示要替换的值 第二个表示要替换开始的下表
        // 三个参数表示第一个表示替换值 第二三 表示替换的范围
        // 22reduceRight 从右往左进行一个累计操作 不会改变原数组 返回值是累计后的值
        // 23copyWithin第一个参数表示要复制开始的位置 第二或者第三个表示要复制的范围
        // 24lastIndexOf 寻找优先符合条件的第一个属性的索引 从右边向左边 找不到就会返回-1 不会改变原始数组
        // 25indexOf 寻找优先符合条件的第一个属性的索引 从左边向右边 找不到就会返回-1 不会改变原始数组
        // keys 对象进行一个遍历操作 返回值是一个数组 遍历的是数组的索引
        // values 对象进行一个遍历操作 返回值是一个数组 遍历的是数组的值
        // entries 对象进行一个遍历操作 返回值是一个数组 遍历的是数组的索引和值
        // forOf 对数组进行一个遍历操作 遍历出数据的每一个属性
        // forIn 对数组进行一个遍历操作 遍历出数据的每一个键和值


    </script>
</body>

</html>